"""
模板数据模型
"""

from typing import Dict, Any, Optional, List
from .base import BaseModel


class Template(BaseModel):
    """模板模型类"""
    
    # 模板类型常量
    TYPE_DOCUMENT = 'document'
    TYPE_PRESENTATION = 'presentation'
    TYPE_REPORT = 'report'
    TYPE_BOOK = 'book'
    TYPE_ARTICLE = 'article'
    TYPE_CUSTOM = 'custom'
    
    # 模板格式常量
    FORMAT_DOCX = 'docx'
    FORMAT_PDF = 'pdf'
    FORMAT_HTML = 'html'
    FORMAT_LATEX = 'latex'
    FORMAT_ODT = 'odt'
    FORMAT_PPTX = 'pptx'
    
    def __init__(self):
        super().__init__('templates')
    
    def create_template(self, template_data: Dict[str, Any]) -> str:
        """
        创建新模板
        
        Args:
            template_data: 模板数据
            
        Returns:
            str: 模板ID
        """
        # 生成模板ID
        template_id = self.generate_id()
        
        # 构建模板记录
        template_record = {
            'template_id': template_id,
            'name': template_data.get('name'),
            'description': template_data.get('description', ''),
            'category': template_data.get('category', 'general'),
            'type': template_data.get('type', self.TYPE_DOCUMENT),
            'formats': template_data.get('formats', [self.FORMAT_DOCX, self.FORMAT_PDF]),
            'file_path': template_data.get('file_path'),
            'thumbnail_path': template_data.get('thumbnail_path'),
            'css_path': template_data.get('css_path'),
            'config': template_data.get('config', {}),
            'is_default': template_data.get('is_default', False),
            'is_active': template_data.get('is_active', True),
            'is_system': template_data.get('is_system', False),
            'user_id': template_data.get('user_id'),  # 创建者ID
            'usage_count': 0,
            'rating': 0,
            'metadata': template_data.get('metadata', {})
        }
        
        # 验证必填字段
        if not template_record['name']:
            raise ValueError("模板名称不能为空")
        
        if not template_record['file_path']:
            raise ValueError("模板文件路径不能为空")
        
        # 检查模板名称是否已存在
        if self.exists({'name': template_record['name']}):
            raise ValueError(f"模板名称 '{template_record['name']}' 已存在")
        
        # 如果设置为默认模板，需要取消其他默认模板
        if template_record['is_default']:
            self.update_many(
                {'is_default': True, 'type': template_record['type']},
                {'is_default': False}
            )
        
        # 创建记录
        self.create(template_record)
        return template_id
    
    def get_template(self, template_id: str) -> Optional[Dict[str, Any]]:
        """
        获取模板信息
        
        Args:
            template_id: 模板ID
            
        Returns:
            Optional[Dict]: 模板信息或None
        """
        return self.find_one({'template_id': template_id})
    
    def get_template_by_name(self, name: str) -> Optional[Dict[str, Any]]:
        """
        根据名称获取模板
        
        Args:
            name: 模板名称
            
        Returns:
            Optional[Dict]: 模板信息或None
        """
        return self.find_one({'name': name})
    
    def get_default_template(self, template_type: str = None) -> Optional[Dict[str, Any]]:
        """
        获取默认模板
        
        Args:
            template_type: 模板类型（可选）
            
        Returns:
            Optional[Dict]: 默认模板信息或None
        """
        query = {'is_default': True, 'is_active': True}
        
        if template_type:
            query['type'] = template_type
        
        return self.find_one(query)
    
    def update_template(self, template_id: str, template_data: Dict[str, Any]) -> bool:
        """
        更新模板信息
        
        Args:
            template_id: 模板ID
            template_data: 更新数据
            
        Returns:
            bool: 是否更新成功
        """
        # 如果更新为默认模板，需要取消其他默认模板
        if template_data.get('is_default'):
            template = self.get_template(template_id)
            if template:
                self.update_many(
                    {'is_default': True, 'type': template.get('type'), 'template_id': {'$ne': template_id}},
                    {'is_default': False}
                )
        
        return self.update_one({'template_id': template_id}, template_data)
    
    def increment_usage_count(self, template_id: str) -> bool:
        """
        增加模板使用次数
        
        Args:
            template_id: 模板ID
            
        Returns:
            bool: 是否更新成功
        """
        template = self.get_template(template_id)
        if not template:
            return False
        
        usage_count = template.get('usage_count', 0) + 1
        
        return self.update_one(
            {'template_id': template_id},
            {'usage_count': usage_count}
        )
    
    def update_rating(self, template_id: str, rating: int) -> bool:
        """
        更新模板评分
        
        Args:
            template_id: 模板ID
            rating: 评分 (1-5)
            
        Returns:
            bool: 是否更新成功
        """
        template = self.get_template(template_id)
        if not template:
            return False
        
        # 验证评分范围
        rating = max(1, min(5, rating))
        
        # 获取当前评分和评分次数
        current_rating = template.get('rating', 0)
        rating_count = template.get('rating_count', 0)
        
        # 计算新评分
        if rating_count == 0:
            new_rating = rating
        else:
            new_rating = ((current_rating * rating_count) + rating) / (rating_count + 1)
        
        # 更新评分
        return self.update_one(
            {'template_id': template_id},
            {
                'rating': round(new_rating, 1),
                'rating_count': rating_count + 1
            }
        )
    
    def get_templates(self, template_type: str = None, category: str = None,
                    is_active: bool = True, is_system: bool = None,
                    limit: int = 50, skip: int = 0) -> List[Dict[str, Any]]:
        """
        获取模板列表
        
        Args:
            template_type: 模板类型过滤（可选）
            category: 分类过滤（可选）
            is_active: 是否活跃（可选）
            is_system: 是否系统模板（可选）
            limit: 限制数量
            skip: 跳过数量
            
        Returns:
            List[Dict]: 模板列表
        """
        query = {}
        
        if template_type:
            query['type'] = template_type
        
        if category:
            query['category'] = category
        
        if is_active is not None:
            query['is_active'] = is_active
        
        if is_system is not None:
            query['is_system'] = is_system
        
        return self.find_many(
            query=query,
            sort=[('is_default', -1), ('usage_count', -1)],
            limit=limit,
            skip=skip
        )
    
    def get_user_templates(self, user_id: str, is_active: bool = None,
                         limit: int = 50, skip: int = 0) -> List[Dict[str, Any]]:
        """
        获取用户创建的模板列表
        
        Args:
            user_id: 用户ID
            is_active: 是否活跃（可选）
            limit: 限制数量
            skip: 跳过数量
            
        Returns:
            List[Dict]: 模板列表
        """
        query = {'user_id': user_id}
        
        if is_active is not None:
            query['is_active'] = is_active
        
        return self.find_many(
            query=query,
            sort=[('created_at', -1)],
            limit=limit,
            skip=skip
        )
    
    def delete_template(self, template_id: str) -> bool:
        """
        删除模板
        
        Args:
            template_id: 模板ID
            
        Returns:
            bool: 是否删除成功
        """
        template = self.get_template(template_id)
        if not template:
            return False
        
        # 如果是系统模板，不允许删除
        if template.get('is_system', False):
            return False
        
        # 如果是默认模板，不允许删除
        if template.get('is_default', False):
            return False
        
        return self.delete_one({'template_id': template_id})
    
    def deactivate_template(self, template_id: str) -> bool:
        """
        停用模板
        
        Args:
            template_id: 模板ID
            
        Returns:
            bool: 是否操作成功
        """
        template = self.get_template(template_id)
        if not template:
            return False
        
        # 如果是默认模板，不允许停用
        if template.get('is_default', False):
            return False
        
        return self.update_one(
            {'template_id': template_id},
            {'is_active': False}
        )
    
    def activate_template(self, template_id: str) -> bool:
        """
        启用模板
        
        Args:
            template_id: 模板ID
            
        Returns:
            bool: 是否操作成功
        """
        return self.update_one(
            {'template_id': template_id},
            {'is_active': True}
        )
    
    def set_default_template(self, template_id: str) -> bool:
        """
        设置默认模板
        
        Args:
            template_id: 模板ID
            
        Returns:
            bool: 是否操作成功
        """
        template = self.get_template(template_id)
        if not template:
            return False
        
        # 确保模板处于活跃状态
        if not template.get('is_active', True):
            return False
        
        # 取消其他同类型默认模板
        self.update_many(
            {'is_default': True, 'type': template.get('type')},
            {'is_default': False}
        )
        
        # 设置为默认模板
        return self.update_one(
            {'template_id': template_id},
            {'is_default': True}
        )